#include <iostream>
#include <cstring>
using namespace std;

// 解决单次查询的函数，计算区间[l, r]内满足条件的(n, m)对数量
long long solve(long long l, long long r) {
    if (l > r) return 0;  // 无效区间直接返回0
    
    // 预处理l和r的31位二进制表示（从最高位到最低位）
    int bits_r[31], bits_l[31];  // 存储二进制位
    for (int i = 0; i < 31; i++) {
        // 提取r的第(30-i)位（最高位存储在bits_r[0]）
        bits_r[i] = (r >> (30 - i)) & 1;
        // 提取l的第(30-i)位（最高位存储在bits_l[0]）
        bits_l[i] = (l >> (30 - i)) & 1;
    }

    // DP数组：dp[i][tight_n][tight_l]
    // i: 当前处理的位数（0-30）
    // tight_n: n是否仍受r的上界约束（1-受约束，0-不受约束）
    // tight_l: m是否仍受l的下界约束（1-受约束，0-不受约束）
    long long dp[32][2][2];
    memset(dp, 0, sizeof(dp));  // 初始化DP数组为0
    dp[0][1][1] = 1;  // 初始状态：从最高位开始，n和m都受约束

    // 从高位到低位遍历31个二进制位
    for (int i = 0; i < 31; i++) {
        // 遍历所有可能的约束状态
        for (int tight_n = 0; tight_n < 2; tight_n++) {
            for (int tight_l = 0; tight_l < 2; tight_l++) {
                if (dp[i][tight_n][tight_l] == 0) continue;  // 跳过无效状态
                
                // 确定n当前位的上限：
                // 若受约束则上限为r的当前位，否则上限为1
                int up_n = (tight_n) ? bits_r[i] : 1;
                
                // 枚举n当前位的可能取值a（0或1）
                for (int a = 0; a <= up_n; a++) {
                    // 根据m是否受下界约束分情况处理
                    if (tight_l) {
                        // 若受约束，则m当前位b的下限为l的当前位
                        int low_m = bits_l[i];
                        // 枚举m当前位b的可能取值（从low_m到1）
                        for (int b = low_m; b <= 1; b++) {
                            // 检查子集条件：m的位不能超过n
                            if (b == 1 && a == 0) continue;  // 违反条件则跳过
                            
                            // 计算新的约束状态：
                            // 若之前受约束且当前位等于边界值，则继续保持约束
                            int new_tight_n = tight_n && (a == bits_r[i]);
                            int new_tight_l = tight_l && (b == bits_l[i]);
                            
                            // 状态转移：累加方案数
                            dp[i+1][new_tight_n][new_tight_l] += dp[i][tight_n][tight_l];
                        }
                    } else {
                        // 若不受约束，则b可取0或1
                        for (int b = 0; b <= 1; b++) {
                            // 检查子集条件
                            if (b == 1 && a == 0) continue;
                            
                            // 计算新的约束状态（下界约束保持解除状态）
                            int new_tight_n = tight_n && (a == bits_r[i]);
                            int new_tight_l = tight_l;  // 下界约束一旦解除不再恢复
                            dp[i+1][new_tight_n][new_tight_l] += dp[i][tight_n][tight_l];
                        }
                    }
                }
            }
        }
    }

    // 统计所有最终状态的结果
    long long ans = 0;
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 2; j++)
            ans += dp[31][i][j];
    return ans;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);  // 优化输入输出
    
    int q;
    cin >> q;  // 读取查询次数
    while (q--) {
        long long l, r;
        cin >> l >> r;  // 读取查询区间
        cout << solve(l, r) << '\n';  // 输出答案
    }
    return 0;
}
